Project - Unsupervised Learning - AIML - Aishik Sengupta¶
Data Description :¶
The data contains features extracted from the silhouette of vehicles in different angles. Four "Corgie" model vehicles were used for the experiment: a double decker bus, Cheverolet van, Saab 9000 and an Opel Manta 400 cars. This particular combination of vehicles was chosen with the expectation that the bus, van and either one of the cars would be readily distinguishable, but it would be more difficult to distinguish between the cars.
Domain :¶
Object recognition
Context :¶
The purpose is to classify a given silhouette as one of three types of vehicle, using a set of features extracted from the silhouette. The vehicle may be viewed from one of many different angles.
Attribute Information :¶
- All the features are geometric features extracted from the silhouette.
- All are numeric in nature.
Learning Outcomes:¶
- Exploratory Data Analysis
- Reduce number dimensions in the dataset with minimal information loss
- Train a model using Principle Components
Objective :¶
Apply dimensionality reduction technique – PCA and train a model using principle components instead of training the model using just the raw data.
Steps and tasks:¶
- Data pre-processing – Perform all the necessary preprocessing on the data ready to be fed to an Unsupervised algorithm
- Understanding the attributes - Find relationship between different attributes (Independent variables) and choose carefully which all attributes have to be a part of the analysis and why
- Split the data into train and test (Suggestion: specify “random state” if you are using train_test_split from Sklearn)
- Train a Support vector machine using the train set and get the accuracy on the test set
- Perform K-fold cross validation and get the cross validation score of the model
- Use PCA from Scikit learn, extract Principal Components that capture about 95% of the variance in the data
- Repeat steps 3,4 and 5 but this time, use Principal Components instead of the original data. And the accuracy score should be on the same rows of test data that were used earlier.
- Compare the accuracy scores and cross validation scores of Support vector machines – one trained using raw data and the other using Principal Components, and mention your findings
In [34]:
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
# various scaling algorithms
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import RobustScaler
from scipy.stats import zscore
from sklearn.impute import SimpleImputer
from sklearn.model_selection import KFold
from sklearn.model_selection import train_test_split # to split the dataset for training and testing
from sklearn.model_selection import cross_val_score # for performing cross validation of models
from sklearn.svm import SVC # Support vector machine model
from sklearn.utils import shuffle
from sklearn import metrics # to get various evaluation metrics
from sklearn.metrics import roc_auc_score # receiver operating curve score
from sklearn.metrics import accuracy_score # accuracy of prediction score
from sklearn.metrics import recall_score # recall score
from sklearn.metrics import precision_score # precision score
from sklearn.metrics import f1_score # f1 score
from sklearn.decomposition import PCA # performing principal components analysis
In [3]:
# read the dataset to a dataframe
df = pd.read_csv('vehicle.csv')
In [4]:
# taking a look at the first 10 rows of the dataframe, already seeing some missing values
df.head(10)
Out[4]:
In [5]:
df.info() # basic info such as datatype, value types
In [12]:
df.shape # dimensions of the dataframe
Out[12]:
Data Preprocessing¶
In [7]:
# To label encode our target variable
encoder = LabelEncoder()
encoder.fit(df['class'])
Out[7]:
In [8]:
df['class'] = encoder.transform(df['class'])
In [9]:
# To check for missing or null values
df.isna().sum()
Out[9]:
In [15]:
#To impute missing values
impute = SimpleImputer( missing_values= np.nan , strategy='median')
#impute = impute.fit(df[:,0:18])
df.iloc[:,0:18] = impute.fit_transform(df.iloc[:,0:18])
In [43]:
# separating the dataframe into three dataframes based on target variable
#bus = df[df['class']==0]
#car = df[df['class']==1]
#van = df[df['class']==2]
In [45]:
# using median to fill the null or missing values of each column based on each vehicle
#medianFiller = lambda x: x.fillna(x.median())
#bus = bus.apply(medianFiller, axis=0)
#car = car.apply(medianFiller, axis=0)
#van = van.apply(medianFiller, axis=0)
In [46]:
#truncating the original dataframe
#df.drop(df.index, inplace=True)
In [47]:
#appending the three dataframes to the original dataframe after filling missing or null values
#df = df.append(bus).append(car).append(van)
In [15]:
#df.sample(frac=1).reset_index(drop= True)
In [16]:
#df = df.sample(frac=1)
In [17]:
# Replacing the null values with median values of proper class vehicle
#i = 0
#while i < len(missing_cols):
# df[df[missing_cols[i]].isna() == True].loc[df['class'] == 0, missing_cols[i]].replace(np.nan,df[df[missing_cols[i]].isna() == False].loc[df['class'] == 0, missing_cols[i]].median())
# df[df[missing_cols[i]].isna() == True].loc[df['class'] == 1, missing_cols[i]].replace(np.nan,df[df[missing_cols[i]].isna() == False].loc[df['class'] == 1, missing_cols[i]].median())
# df[df[missing_cols[i]].isna() == True].loc[df['class'] == 2, missing_cols[i]].replace(np.nan,df[df[missing_cols[i]].isna() == False].loc[df['class'] == 2, missing_cols[i]].median())
# i += 1
In [18]:
# Taking a look at the missing or null values, no more present after median filling data
df.isna().sum()
Out[18]:
In [19]:
# just to check the new df in csv file
df.to_csv('check1.csv')
In [50]:
# to shuffle the rows of the dataset after appending to get mixed rows
#df = shuffle(df)
In [51]:
#df.reset_index(drop = True, inplace = True) # reset index after shuffle
In [20]:
df['class'] = df['class'].astype('category')
In [21]:
df.info()
In [24]:
#numeric_cols = df.select_dtypes(include=[np.int64, np.float64]).columns
#numeric_cols
In [25]:
#df[numeric_cols] = df[numeric_cols].apply(zscore)
Understanding the relationship b/w Independent variables¶
In [22]:
# Doing a boxplot on the whole data to check
sns.boxplot( data=df, orient= "h" )
Out[22]:
Univariate Analysis¶
In [23]:
plt.figure(figsize = (18,132))
cols = df.columns.values
i=0 # column counter
j=1 # plot counter
k=1 # plot counter of each variable
while i < (len(cols) - 1):
if k == 1:
plt.subplot(18,3,j)
sns.distplot(df[df['class'] == 0][cols[i]], color= 'black', label='Bus')
sns.distplot(df[df['class'] == 1][cols[i]], color = 'orange', label='Car')
sns.distplot(df[df['class'] == 2][cols[i]], color = 'red', label='Van')
j+=1
k+=1
plt.title(f'Distribution of {cols[i]}')
plt.xlabel(f'{cols[i]}')
plt.ylabel('Frequency')
plt.legend()
elif k == 2:
plt.subplot(18,3,j)
sns.distplot(df[cols[i]])
j+=1
k+=1
plt.title(f'Distribution of {cols[i]}')
plt.xlabel(f'{cols[i]}')
plt.ylabel('Frequency')
else:
plt.subplot(18,3,j)
sns.boxplot(df[cols[i]], color='yellowgreen')
j+=1
q1, q3 = np.percentile(df[cols[i]],[25,75])
IQR = q3 - q1
plt.title(f'Boxplot of {cols[i]} \n \u03bc = {round(df[cols[i]].mean(), 3)}, SE = {round(df[cols[i]].std(),4)}, Median = {round(df[cols[i]].median(),3)}, IQR = {round(IQR, 3)} ')
plt.xlabel(f'{cols[i]}')
plt.ylabel('Frequency')
i+=1
k=1
Insights From Univariate Analysis¶
- The distance plots represent almost normal distribution or bi-modal distribution.
- From the boxplots, we can see outliers present in skewness_about.1, skewness_about, scaled_radius_of_gyration.1, scaled_variance, scaled_variance.1, max_length_aspect_ratio, pr.axis_aspect_ratio and radius_ratio
- We are not going to remove outliers as the dataset itself is small, outliers are few in number here and would not want to cause any critical loss of data if they hold any. Plus we dont have much domain expertise on the predictors.
- Regarding the distance plots concerning the target variables, we can see there is high overlap of data between all the vehicles. Visualization is not enough to see the independence of data among target variables.
- Visually the predictors which show some independence among the target variables are skewness_about.2, scaled_variance.1, scaled_variance, scatter_ratio, elongatedness, pr.axis_rectangularity and distance_circularity
In [29]:
sns.pairplot(df, diag_kind='kde')
Out[29]:
Insights From Pair Plots¶
- elongatedness seems to have a high negative correlation with multiple attributes like compactness, circularity, distance_circularity, radius_ratio, scatter_ratio, pr_axis.rectangularity, max_length.rectangularity, scaled_variance, scaled_variance.1 and scaled_radius_of_gyration
- compactness seems to have a high positive correlation with pr_axis.rectangularity and scaled_variance.1
- distance_circularity and radius_ratio seems to have a good positive correlation with scaled_radius_of_gyration, scaled_variance, scaled_variance.1 and pr_axis.rectangularity
- skewness_About.2 and hollows_ratio is positively correlated.
- scatter_ratio has a positive correlation with pr_axis.rectangularity, max_length.rectangularity, scaled_variance, scaled_variance.1 and scaled_radius_of_gyration
- scaled_variance and scaled_variance.1 is highly correlated
- The seven variables of elongatedness,scatter_ratio, pr_axis.rectangularity, max_length.rectangularity, scaled_variance, scaled_variance.1 and scaled_radius_of_gyration are high correlated among each other
Plotting a HeatMap to confirm above insights and get actual pearson correlation coefficient¶
In [35]:
colormap = plt.cm.magma
plt.figure(figsize=(20,20))
sns.heatmap(df.corr(), linewidths=0.1, vmax=1.0,
square=True, cmap=colormap, linecolor='white', annot=True)
Out[35]:
Insights From HeatMap¶
High Correlation¶
- scaled_variance & scaled_variance.1 seems to be strongly correlated with value of 0.95
- skewness_about.2 and hollow_ratio seems to be strongly correlated with value of 0.89
- elongatedness has multiple highly negatively correlated values with various attributes as seen in the heatmap
- scatter_ratio has vales over 0.95 with scaled_variance, scaled_variance.1 and pr_axis.rectangularity
- scaled_variance & scaled_variance.1 maintains almost same correlation with other attributes with coefficient verying b/w them at less than 0.5
- scaled_radius_of_gyration has a high postive correlation with circularity
Low Correlation¶
- max_length_aspect_ratio & radius_ratio have average correlation with coeff: 0.45
- skewness_about , skewness_about.1 and skewness_about.2 have almost no correlation with the other attributes except b/w skewness_about.2 and hollows_ratio and scaled_radius_of_gyration.1 . Same goes for hollows_ratio.
- scaled_radius_gyration & scaled_radius_gyration.1 seems to be very little correlated
- pr.axis_aspect_ratio and max.length_aspect_ratio does not have much correlation with other attributes except with radius_ratio and among themselves.
- scaled_radius_gyration.1 does not have much correlation with other attributes
Final Thoughts On Choosing The Right Predictors¶
Since our objective is to reocgnize whether an object is a van or bus or car based on some input features, our main assumption is that there is little or no multicollinearity between the features. if our dataset has perfectly positive or negative attributes as can be obseverd from our correlation analysis, there is a high chance that the performance of the model will be impacted by a problem called — “Multicollinearity”. Multicollinearity happens when one predictor variable in a multiple regression model can be linearly predicted from the others with a high degree of accuracy. This can lead to skewed or misleading results.
If two features is highly correlated then there is no point using both features. In such cases, we can drop one of the two correlated feature or transform the two correlated features into a third feature and drop the original two features.
From above correlation matrix we can see that there are many features which are highly correlated. if we carefully analyse, we will find that many features are there which having more than 0.8 correlation, so we can decide to get rid of those columns whose correlation is +-0.8 or above.There are 8 such columns:
- max.length_rectangularity
- scaled_radius_of_gyration
- scatter_ratio
- elongatedness
- pr.axis_rectangularity
- scaled_variance
- scaled_variance.1
- compactness
- circularity
- distance_circularity
- radius_ratio
Also we observed that more than 50 % of our attributes ar highly correlated.
Well, There are multiple ways to deal with this problem. The easiest way is to delete or eliminate one of the perfectly correlated features. We can pick one of the tiwo highly correalated variables and drop another one. Like in our case scaled_variance & scaled_variance.1 are having strong positive correlation , so we can pick one and drop one as they will only make our dimension redundant. Or create a third transformed variable from these two and drop the original two.
Similarly between elongatedness and pr.axis_rectangularity we can pick one as they have very strong negative correlation. This approach can be used to select the feature we want to carry forward for model analysis. But there is another better approach called PCA
Enter Principal Components Analysis or PCA¶
But first lets check the performance on non-PCA SVM which we will compare on PCA SVM¶
Splitting the dataset¶
In [25]:
X = df.drop('class', axis=1)
y = df['class']
In [26]:
X_train, X_test, y_train, y_test = train_test_split(X , y ,test_size = 0.30 , random_state = 1, stratify = y)
In [27]:
scale = StandardScaler() # Standard scaling
scale.fit(X_train.loc[:,:])# fitting on training data so the data integrity in test is maintained
X_train_scaled = scale.transform(X_train.loc[:,:])
X_test_scaled = scale.transform(X_test.loc[:,:])
In [28]:
X_train.loc[:,:] = X_train_scaled[:,:]
X_test.loc[:,:] = X_test_scaled[:,:]
In [29]:
X_train.head()
Out[29]:
In [30]:
def draw_confusionmatrix(y_test, y_pred, cat1, cat2, cat3, dataset ):
cm = metrics.confusion_matrix( y_test, y_pred, [0,1,2] )
print("Confusion Matrix For : \n " ,dataset)
print(cm)
sns.heatmap(cm, annot=True, fmt='.1f' ,xticklabels = [cat1, cat2,cat3] , yticklabels = [cat1, cat2,cat3] )
plt.ylabel('True Vehicle')
plt.xlabel('Predicted Vehicle')
plt.show()
In [31]:
#using SVM to train model
svc = SVC( C=1, gamma='auto')
svc.fit(X_train, y_train)
print("Accuracy on training set: {:.6f}".format(svc.score(X_train, y_train)))
print("Accuracy on test set: {:.6f}".format(svc.score(X_test, y_test)))
y_predict = svc.predict(X_test)
In [32]:
# Getting the confusion matrix
draw_confusionmatrix(y_test, y_predict,"Bus", "Car", "Van", "Scaled Data Set" )
Classification Report For Scaled Data:¶
In [33]:
print(metrics.classification_report(y_test,y_predict))
The model correctly predicted 63 buses, 123 cars and 58 vans. It incorrectly predicted two buses as vans, six cars as vans and two vans as a car and a bus each.
Performing K Fold Cross Validation¶
In [35]:
#Perform cross validation
models = []
models.append(('P01', 0.1, 'poly'))
models.append(('P1', 1, 'poly'))
models.append(('P10', 10, 'poly'))
models.append(('P20', 20, 'poly'))
models.append(('P30', 30, 'poly'))
models.append(('S01', 0.1, 'sigmoid'))
models.append(('S1', 1, 'sigmoid'))
models.append(('S10', 10, 'sigmoid'))
models.append(('S20', 20, 'sigmoid'))
models.append(('S30', 30, 'sigmoid'))
models.append(('R01', 0.1, 'rbf'))
models.append(('R1', 10, 'rbf'))
models.append(('R10', 10, 'rbf'))
models.append(('R20', 20, 'rbf'))
models.append(('R30', 30, 'rbf'))
# evaluate each model in turn
results = []
names = []
In [36]:
scale2 = StandardScaler() # Standard scaling
scale2.fit(X.loc[:,:])# fitting on training data so the data integrity in test is maintained
X_scaled = scale2.transform(X.loc[:,:])
In [37]:
X_scaled
Out[37]:
In [39]:
kfold = KFold( n_splits=10, shuffle=True, random_state=1)
for name, c, kernels in models:
cv_results = cross_val_score( SVC( C=c ,kernel = kernels, gamma = 'auto' ), X_scaled, y, cv=kfold, scoring= 'accuracy')
results.append(cv_results)
names.append(name)
msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std())
print('Accuracy of ' + msg)
Let me take the RBF kernel having regularization parameter of 10 to find its Stats¶
In [51]:
#using SVM to train model
svc = SVC( C=10, gamma='auto')
svc.fit(X_train, y_train)
print("Accuracy on training set: {:.6f}".format(svc.score(X_train, y_train)))
print("Accuracy on test set: {:.6f}".format(svc.score(X_test, y_test)))
y_predict = svc.predict(X_test)
In [52]:
# Getting the confusion matrix
draw_confusionmatrix(y_test, y_predict,"Bus", "Car", "Van", "Scaled Data Set" )
In [53]:
print(metrics.classification_report(y_test,y_predict))
After doing cross validation after tuning the hyperparameters, the SVM with rbf kernel and C = 10 looks good, with gamma set to auto. The model correctly predicted 63 buses, 125 cars and 58 vans. It incorrectly predicted two buses as vans, four cars as vans and two vans as cars.
Finding the Principal Components¶
In [56]:
#should give an 18*18 matrix
covMatrix = np.cov(X_scaled,rowvar=False)
print(covMatrix)
In [57]:
#Performing PCA on all of its 18 predictors
pca = PCA(n_components=18)
pca.fit(X_scaled)
Out[57]:
In [58]:
#Eigen Values or the variance explained by each of the components
print(pca.explained_variance_)
In [59]:
#Eigen vectors
print(pca.components_)
In [60]:
# To find the percentage of variance explained by each of the components / predictors
print(pca.explained_variance_ratio_)
In [62]:
# To find the cumulative sum of variances explained by the components
print(np.cumsum(pca.explained_variance_ratio_))
From the cumulative sum above , it looks like 95% of the variance is explained by the first 7 components. Therefore 7 dimensions are enough.
Have a look at the pairplot with all PCA reduced dimensions¶
In [63]:
sns.pairplot( pd.DataFrame(pca.transform(X_scaled)), diag_kind='kde')
Out[63]:
In [64]:
plt.bar(range(1,19), pca.explained_variance_ratio_, alpha = 0.5, align='center', label='individual explained variance')
plt.step( range(1,19), np.cumsum(pca.explained_variance_ratio_), where='mid', label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.legend(loc = 'best')
plt.show()
It looks like 7 dimensions are enough to explain the 95% of the variance in data¶
Lets get the reduced dimensions dataset from PCA¶
In [65]:
pca2 = PCA(n_components=7)
pca2.fit(X_scaled)
print(pca2.components_)
print(pca2.explained_variance_ratio_)
# getting the dataset of the reduced set of dimensions that we will feed to SVM later on
Xpca =pca2.transform(X_scaled)
In [67]:
# Checking the cumulative variance
print(np.cumsum(pca2.explained_variance_ratio_))
In [68]:
# Xpca is an ndarray, need to convert to a dataframe
Xdf = pd.DataFrame(Xpca)
In [69]:
Xdf
Out[69]:
Having a look at the pairplot pf reduced dimensions after PCA¶
In [70]:
sns.pairplot(Xdf, diag_kind='kde')
Out[70]:
It is clealry visible from the pairplot above that:¶
After dimensionality reduction using PCA our attributes have become independent with no correlation among themselves. As most of them have cloud of data points with no lienaer kind of relationship.
In [71]:
plt.bar(range(1,8), pca2.explained_variance_ratio_, alpha = 0.5, align='center', label='individual explained variance')
plt.step( range(1,8), np.cumsum(pca2.explained_variance_ratio_), where='mid', label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.legend(loc = 'best')
plt.show()
Building SVM model on PCA reduced set of data¶
In [72]:
pca_X_train,pca_X_test,pca_y_train,pca_y_test = train_test_split( Xdf, y, test_size=0.30, random_state=1, stratify = y)
In [74]:
#using SVM to train model
svc = SVC( C=10, gamma='auto')
svc.fit(pca_X_train, pca_y_train)
print("Accuracy on training set: {:.6f}".format(svc.score(pca_X_train, pca_y_train)))
print("Accuracy on test set: {:.6f}".format(svc.score(pca_X_test, pca_y_test)))
pca_y_predict = svc.predict(pca_X_test)
In [75]:
# Getting the confusion matrix
draw_confusionmatrix(pca_y_test, pca_y_predict,"Bus", "Car", "Van", "PCA Reduced Data Set" )
In [76]:
print(metrics.classification_report(pca_y_test,pca_y_predict))
After running the SVM model on the PCA reduced set of scaled data, the model correctly predicted 60 buses, 115 cars and 54 vans. It incorrectly predicted two buses as vans, three buses as cars, ten cars as vans, four cars as buss and six vans as cars.
In [77]:
#Perform cross validation
models2 = []
models2.append(('P01', 0.1, 'poly'))
models2.append(('P1', 1, 'poly'))
models2.append(('P10', 10, 'poly'))
models2.append(('P20', 20, 'poly'))
models2.append(('P30', 30, 'poly'))
models2.append(('S01', 0.1, 'sigmoid'))
models2.append(('S1', 1, 'sigmoid'))
models2.append(('S10', 10, 'sigmoid'))
models2.append(('S20', 20, 'sigmoid'))
models2.append(('S30', 30, 'sigmoid'))
models2.append(('R01', 0.1, 'rbf'))
models2.append(('R1', 10, 'rbf'))
models2.append(('R10', 10, 'rbf'))
models2.append(('R20', 20, 'rbf'))
models2.append(('R30', 30, 'rbf'))
# evaluate each model in turn
results2 = []
names2 = []
In [78]:
kfold = KFold( n_splits=10, shuffle=True, random_state=1)
for name, c, kernels in models2:
cv_results2 = cross_val_score( SVC( C=c ,kernel = kernels, gamma = 'auto' ), Xdf, y, cv=kfold, scoring= 'accuracy')
results2.append(cv_results2)
names2.append(name)
msg = "%s: %f (%f)" % (name, cv_results2.mean(), cv_results2.std())
print('Accuracy of ' + msg)
In [89]:
#using SVM to train model
svc2 = SVC( C=10, gamma='auto')
svc2.fit(pca_X_train, pca_y_train)
print("Accuracy on training set: {:.6f}".format(svc2.score(pca_X_train, pca_y_train)))
print("Accuracy on test set: {:.6f}".format(svc2.score(pca_X_test, pca_y_test)))
pca_y_predict = svc2.predict(pca_X_test)
In [83]:
print(accuracy_score(pca_y_test,pca_y_predict))
In [84]:
# Getting the confusion matrix
draw_confusionmatrix(pca_y_test, pca_y_predict,"Bus", "Car", "Van", "PCA Reduced Data Set" )
In [85]:
print(metrics.classification_report(pca_y_test,pca_y_predict))
After doing cross validation after tuning the hyperparameters, the SVM with rbf kernel and C = 10 looks good, with gamma set to auto. The model correctly predicted 60 buses, 115 cars and 54 vans. It incorrectly predicted two buses as vans, three buses as cars, four cars as buses, ten cars as vans and six vans as cars.
To find correlation b/w components and features¶
In [90]:
df_comp = pd.DataFrame(pca2.components_,columns=list(X.columns.values))
In [91]:
plt.figure(figsize=(12,6))
sns.heatmap(df_comp,cmap='plasma')
Out[91]:
- From above, PC1 belongs to the predictor - 'elongatedness'
- PC2 belongs to scaled_radius_of_gyration.1, skewness_about.2 and hollows_ratio
- PC3 belongs to pr.axis_aspect_ratio andmax.length_aspect_ratio, and so on
Final Verdict¶
- The accuracy score of SVM model using raw data is around 96%. This uses the scaled data of all the 18 dimensions.
- The cross validation score of the SVM model on raw data is around 98.5%. This also uses the scaled data of all the 18 dimensions.
- The accuracy score of SVM model using PCA reduced set of data is around 90%. This uses seven dimensions instead of the original 18 dimensions. The accuracy went down by 6% from the original set of 18 dimensions and by 8.5% on cross validation score. Not bad considering it used 11 less dimensions.
- The cross validation score of the SVM model on raw data is around 93.5%. This uses seven dimensions instead of the original 18 dimensions. The score here is pretty impressive considering it uses 11 less dimensions and is just 5% shy of the raw data cross validation score.
- Such PCA reduced data should do well with Naive Bayes model, considering the relevant theory behind Naive Bayes and PCA.
- Finally I would choose the model with cross valdiation score of 98.5% having all the 18 dimensions as it is normal for SVM to handle such multiple dimensions.